use std::{net::SocketAddr, sync::Arc};

// 关键修复1：仅导入 anyhow 必要项，不导入 Ok/Err 变体（避免冲突）
use anyhow::{anyhow, Result};
use axum::{
    routing::{delete, get, post},
    Router, serve,
};
use http::{HeaderValue, Method};
use log::{error, info, warn, debug}; // 日志宏
// 关键修复2：删除未使用的 tower::ServiceBuilder 导入（解决警告）
use tower_http::cors::CorsLayer;
use tokio::net::TcpListener;

use crate::{auth, AppState};

mod assets;
mod messages;
mod version;
mod websocket;

pub struct Builder {
    http_auth: bool,
    socket: Option<SocketAddr>,
    state: Option<Arc<AppState>>,
}

impl Default for Builder {
    fn default() -> Self {
        Self::new()
    }
}

pub struct Server {
    router: Router,
    socket: SocketAddr,
}

impl Server {
    /// 启动服务器（彻底修复模式匹配错误）
    pub async fn serve(self) -> Result<()> {
        info!("API服务器开始启动，监听地址: http://{}", self.socket);

        // 关键修复3：直接匹配 anyhow::Result 的 Ok/Err，无需导入变体
        let listener = match TcpListener::bind(self.socket).await {
            // 使用标准 Result 匹配（TcpListener::bind 返回 std::io::Result，其 Ok 是内置模式）
            Ok(listener) => {
                info!("API服务器成功绑定到地址: http://{}", self.socket);
                listener
            }
            Err(e) => {
                error!("API服务器绑定地址失败: http://{}, 错误原因: {}", self.socket, e);
                // 转换为 anyhow::Result 的错误（显式调用 anyhow!）
                return Err(anyhow!("绑定地址失败: {}", e));
            }
        };

        info!("API服务器启动成功，开始处理请求...");
        // 关键修复4：同样使用标准 Result 匹配 axum::serve 的返回值
        match serve(listener, self.router.into_make_service()).await {
            Ok(_) => {
                info!("API服务器正常停止");
                // 直接返回 anyhow::Result 的 Ok（无需导入变体）
                Ok(())
            }
            Err(e) => {
                error!("API服务器运行出错: {}", e);
                return Err(anyhow!("服务器运行失败: {}", e));
            }
        }
    }
}

impl Builder {
    pub fn new() -> Self {
        Builder {
            http_auth: false,
            socket: None,
            state: None,
        }
    }

    pub fn http_auth(mut self, value: bool) -> Self {
        self.http_auth = value;
        self
    }

    pub fn bind(mut self, socket: SocketAddr) -> Self {
        self.socket = Some(socket);
        self
    }

    pub fn with_state(mut self, state: Arc<AppState>) -> Self {
        self.state = Some(state);
        self
    }

    pub fn build(self) -> Server {
        // 验证必要参数（添加错误日志）
        let state = self.state.as_ref().expect("API Builder requires a valid AppState");
        let socket = self.socket.expect("API Builder requires a valid SocketAddr");

        debug!(
            "开始构建API服务器: 地址={}, HTTP认证={}",
            socket, self.http_auth
        );

        // 配置CORS（清理重复层，避免冲突）
        let cors = CorsLayer::new()
            .allow_origin(HeaderValue::from_static("http://localhost:5173"))
            .allow_methods([Method::GET, Method::POST, Method::DELETE, Method::OPTIONS])
            .allow_headers([http::header::CONTENT_TYPE, http::header::AUTHORIZATION]);

        // 构建路由（移除重复的 CorsLayer::permissive()）
        let router = Router::new()
            .route("/", get(assets::index_html))
            .route("/ws", get(websocket::websocket_handler))
            .route("/mailtutan-web_bg.wasm", get(assets::wasm))
            .route("/styles.css", get(assets::css))
            .route("/mailtutan-web.js", get(assets::js))
            .route("/api/messages", get(messages::index))
            .route("/api/messages/{id}/source", get(messages::show_source))
            .route("/api/messages/{id}/plain", get(messages::show_plain))
            .route("/api/messages/{id}/html", get(messages::show_html))
            .route("/api/messages/{id}/json", get(messages::show_json))
            .route("/api/messages/{id}/eml", get(messages::show_eml))
            .route("/api/messages/{id}", delete(messages::delete))
            .route("/api/messages/eml", post(messages::create_message))
            .route(
                "/api/messages/{id}/parts/{cid}",
                get(messages::download_attachment),
            )
            .route("/api/messages", delete(messages::delete_all))
            .route("/api/version", get(version::show))
            .layer(cors) // 仅保留自定义CORS配置
            .with_state(state.clone());

        // 添加认证中间件（记录日志）
        let router = if self.http_auth {
            info!("API服务器启用HTTP基础认证");
            router.route_layer(axum::middleware::from_fn_with_state(state.clone(), auth::basic))
        } else {
            warn!("API服务器未启用认证（生产环境不推荐）");
            router
        };

        info!("API服务器构建完成，绑定地址: http://{}", socket);
        Server {
            router,
            socket,
        }
    }
}
